Over the last week we’ve been taking a journey through ways to think differently about how to code the Look-and-Say sequence using some code examples. Today, we continue that journey through the eyes of a Scala enthusiast.

Ricky’s submission was the unique Scala submission. It has recursive, regular expression, and non-recursive solutions. It demonstrates use of a left-fold operation — one of a number of functional language operations not currently available in the Java 7 standard libraries. This being the version that most, if not all of us, use on project. However, some higher-order functions, including a variation of the left fold, are available in Java 8 and I’m sure we all look forward to the day when we can use these features from 9-5!

Take a look at Ricky’s code…

	package lookandsay
	import scala.collection.mutable.ListBuffer
	import java.math.{BigInteger => JBInt}
	object Main {
	def main(args: Array[String]) {
	println("Look-And-Say-Sequence-Standard")
	var seq = "1"
	for(x <- 1 to 10){
	println(seq)
	seq = standard(new JBInt(seq))
	}
	println
	println("Look-And-Say-Sequence-RegEx")
	seq = "1"
	for( x <- 1 to 10){
	println(seq)
	seq = regex(new JBInt(seq))
	}
	println
	println("Look-And-Say-Sequence-Recursive")
	seq = "1"
	for( x <- 1 to 10){
	println(seq)
	seq = recursive(new JBInt(seq))
	}
	}
	/***
	* Look and Say Sequence Implemented in Standard Form
	*/
	def standard(seed: BigInt): String = {
	var seedStr = seed.toString
	seedStr.foldLeft(new StringBuilder){
	(sb, currChar) =>
	val restOfStr = seedStr.dropWhile(c => c == currChar)
	val count = seedStr.size - restOfStr.size
	seedStr = restOfStr
	if(count > 0 ) sb.append(count.toString + currChar) else sb.append("")
	}.toString
	}
	/**
	* Look and Say Sequence Implemented with RegEx
	*/
	def regex(seed: BigInt): String = {
	val regex = """(\d)\1*""".r
	regex.findAllMatchIn(seed.toString).foldLeft(new StringBuilder){
	(sb, regexMatch) => sb.append(regexMatch.matched.size.toString + regexMatch.group(1))
	}.toString
	}
	/**
	* Look and Say Sequence Implemented with Recursion
	*/
	def recursive(seed: BigInt): String = {
	def recurse(chars: List[Char], count: Int, sb: StringBuilder): String = chars match {
	case Nil => sb.toString
	case head::tail if(tail.isEmpty) => recurse(tail, 1, sb.append(count.toString + head))
	case head::tail if(head == tail.head) => recurse(tail, count + 1, sb)
	case head::tail => recurse(tail, 1, sb.append(count.toString + head))
	}
	recurse(seed.toString.toList, 1, new StringBuilder)
	}
	}

view raw main.scala hosted with by GitHub

	package object common {
	import org.scalatest._
	import org.scalatest.MustMatchers
	abstract class UnitSpec extends WordSpec with MustMatchers with LookAndSay {
	"1" must {
	"""read off as "one 1" or 11.""" in {
	lookAndSay(1) must be("11")
	}
	}
	"11" must {
	"""read off as "two 1s" or 21.""" in {
	lookAndSay(11) must be("21")
	}
	}
	"21" must {
	"""read off as "one 2, then one 1" or 1211.""" in {
	lookAndSay(21) must be("1211")
	}
	}
	"1211" must {
	"""read off as "one 1, then one 2, then two 1s" or 111221""" in {
	lookAndSay(1211) must be("111221")
	}
	}
	"111221" must {
	"""read off as "three 1s, then two 2s, then one 1" or 312211."""
	lookAndSay(111221) must be("312211")
	}
	}
	trait LookAndSay {
	def lookAndSay(seed: BigInt): String
	}
	}

view raw package.scala hosted with by GitHub

	package lookandsay
	import common._
	class StandardLookAndSaySpec extends UnitSpec with StandardLookAndSay
	class RecursiveLookAndSaySpec extends UnitSpec with RecursiveLookAndSay
	class RegExLookAndSaySpec extends UnitSpec with RegExLookAndSay
	trait StandardLookAndSay {
	import Main.standard
	def lookAndSay(seed: BigInt): String = standard(seed)
	}
	trait RecursiveLookAndSay {
	import Main.recursive
	def lookAndSay(seed: BigInt): String = recursive(seed)
	}
	trait RegExLookAndSay {
	import Main.regex
	def lookAndSay(seed: BigInt): String = regex(seed)
	}

view raw LookandSaySpec.scala hosted with by GitHub